// Chrome扩展API工具函数

/**
 * 获取Chrome存储数据
 * @param {string|string[]} keys - 要获取的键名
 * @returns {Promise<any>} 存储的数据
 */
export async function getStorage(keys) {
  return new Promise((resolve, reject) => {
    if (typeof chrome !== 'undefined' && chrome.storage) {
      chrome.storage.local.get(keys, (result) => {
        if (chrome.runtime.lastError) {
          reject(chrome.runtime.lastError)
        } else {
          resolve(result)
        }
      })
    } else {
      // 开发环境模拟数据
      const mockData = {
        isEnabled: true,
        domainWhitelist: ['api.example.com', 'test.baidu.com'],
        mockList: [
          {
            url: 'api.example.com/test',
            method: 'GET',
            status: 200,
            delay: 0,
            response: '{"message": "success", "data": []}',
            enabled: true
          }
        ],
        requestHistory: [
          {
            url: 'https://api.example.com/users',
            method: 'GET',
            status: 200,
            timestamp: Date.now() - 1000000,
            headers: { 'Content-Type': 'application/json' },
            responseBody: '{"users": []}'
          }
        ]
      }
      
      if (typeof keys === 'string') {
        resolve({ [keys]: mockData[keys] })
      } else if (Array.isArray(keys)) {
        const result = {}
        keys.forEach(key => {
          result[key] = mockData[key]
        })
        resolve(result)
      } else {
        resolve(mockData)
      }
    }
  })
}

/**
 * 设置Chrome存储数据
 * @param {Object} data - 要存储的数据
 * @returns {Promise<void>}
 */
export async function setStorage(data) {
  return new Promise((resolve, reject) => {
    if (typeof chrome !== 'undefined' && chrome.storage) {
      chrome.storage.local.set(data, () => {
        if (chrome.runtime.lastError) {
          reject(chrome.runtime.lastError)
        } else {
          resolve()
        }
      })
    } else {
      // 开发环境模拟
      console.log('Mock storage set:', data)
      resolve()
    }
  })
}

/**
 * 删除Chrome存储数据
 * @param {string|string[]} keys - 要删除的键名
 * @returns {Promise<void>}
 */
export async function removeStorage(keys) {
  return new Promise((resolve, reject) => {
    if (typeof chrome !== 'undefined' && chrome.storage) {
      chrome.storage.local.remove(keys, () => {
        if (chrome.runtime.lastError) {
          reject(chrome.runtime.lastError)
        } else {
          resolve()
        }
      })
    } else {
      // 开发环境模拟
      console.log('Mock storage remove:', keys)
      resolve()
    }
  })
}

/**
 * 打开选项页面
 */
export function openOptionsPage() {
  if (typeof chrome !== 'undefined' && chrome.runtime) {
    chrome.runtime.openOptionsPage()
  } else {
    // 开发环境模拟
    window.open('/options.html', '_blank')
  }
}

/**
 * 发送消息到background script
 * @param {Object} message - 要发送的消息
 * @returns {Promise<any>} 响应数据
 */
export async function sendMessage(message) {
  return new Promise((resolve, reject) => {
    if (typeof chrome !== 'undefined' && chrome.runtime) {
      chrome.runtime.sendMessage(message, (response) => {
        if (chrome.runtime.lastError) {
          reject(chrome.runtime.lastError)
        } else {
          resolve(response)
        }
      })
    } else {
      // 开发环境模拟
      console.log('Mock message sent:', message)
      resolve({ success: true })
    }
  })
}

/**
 * 获取当前活动标签页
 * @returns {Promise<chrome.tabs.Tab>} 当前标签页信息
 */
export async function getCurrentTab() {
  return new Promise((resolve, reject) => {
    if (typeof chrome !== 'undefined' && chrome.tabs) {
      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
        if (chrome.runtime.lastError) {
          reject(chrome.runtime.lastError)
        } else {
          resolve(tabs[0])
        }
      })
    } else {
      // 开发环境模拟
      resolve({
        id: 1,
        url: 'https://example.com',
        title: 'Example Page'
      })
    }
  })
}

/**
 * 检查是否在Chrome扩展环境中
 * @returns {boolean}
 */
export function isChromeExtension() {
  return typeof chrome !== 'undefined' && chrome.runtime && chrome.runtime.id
}

/**
 * 格式化JSON字符串
 * @param {any} obj - 要格式化的对象
 * @param {number} space - 缩进空格数
 * @returns {string} 格式化后的JSON字符串
 */
export function formatJSON(obj, space = 2) {
  try {
    if (typeof obj === 'string') {
      // 尝试解析字符串为JSON
      const parsed = JSON.parse(obj)
      return JSON.stringify(parsed, null, space)
    }
    return JSON.stringify(obj, null, space)
  } catch (error) {
    // 如果不是有效的JSON，直接返回原字符串
    return typeof obj === 'string' ? obj : String(obj)
  }
}

/**
 * 验证JSON字符串
 * @param {string} jsonString - JSON字符串
 * @returns {boolean} 是否为有效JSON
 */
export function isValidJSON(jsonString) {
  try {
    JSON.parse(jsonString)
    return true
  } catch (error) {
    return false
  }
}

/**
 * 格式化时间戳
 * @param {number} timestamp - 时间戳
 * @returns {string} 格式化后的时间字符串
 */
export function formatTime(timestamp) {
  const date = new Date(timestamp)
  return date.toLocaleString('zh-CN', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit'
  })
}

/**
 * 格式化文件大小
 * @param {number} bytes - 字节数
 * @returns {string} 格式化后的大小字符串
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 导出数据为JSON文件
 * @param {any} data - 要导出的数据
 * @param {string} filename - 文件名
 */
export function exportToJSON(data, filename) {
  const jsonString = JSON.stringify(data, null, 2)
  const blob = new Blob([jsonString], { type: 'application/json' })
  const url = URL.createObjectURL(blob)
  
  const a = document.createElement('a')
  a.href = url
  a.download = filename
  document.body.appendChild(a)
  a.click()
  document.body.removeChild(a)
  URL.revokeObjectURL(url)
}

/**
 * 从文件导入JSON数据
 * @param {File} file - 文件对象
 * @returns {Promise<any>} 解析后的JSON数据
 */
export function importFromJSON(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader()
    
    reader.onload = (e) => {
      try {
        const data = JSON.parse(e.target.result)
        resolve(data)
      } catch (error) {
        reject(new Error('文件格式错误，请选择有效的JSON文件'))
      }
    }
    
    reader.onerror = () => {
      reject(new Error('文件读取失败'))
    }
    
    reader.readAsText(file)
  })
}

/**
 * 深拷贝对象
 * @param {any} obj - 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime())
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item))
  }
  
  if (typeof obj === 'object') {
    const cloned = {}
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        cloned[key] = deepClone(obj[key])
      }
    }
    return cloned
  }
  
  return obj
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 限制时间（毫秒）
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}

/**
 * URL匹配检查
 * @param {string} url - 要检查的URL
 * @param {string} pattern - 匹配模式
 * @returns {boolean} 是否匹配
 */
export function matchURL(url, pattern) {
  // 简单的通配符匹配
  const regex = new RegExp(pattern.replace(/\*/g, '.*').replace(/\?/g, '.'))
  return regex.test(url)
}

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substr(2)
}

/**
 * 获取域名
 * @param {string} url - URL字符串
 * @returns {string} 域名
 */
export function getDomain(url) {
  try {
    const urlObj = new URL(url)
    return urlObj.hostname
  } catch (error) {
    return ''
  }
}

/**
 * 检查URL是否在白名单中
 * @param {string} url - 要检查的URL
 * @param {string[]} whitelist - 白名单数组
 * @returns {boolean} 是否在白名单中
 */
export function isURLInWhitelist(url, whitelist) {
  if (!whitelist || whitelist.length === 0) {
    return false
  }
  
  const domain = getDomain(url)
  return whitelist.some(pattern => {
    return domain.includes(pattern) || url.includes(pattern)
  })
}